Activity的Finish过程分析

发表于 | 分类于 | 阅读次数:

Activity的finish过程分析

废话不多说了，直接上代码。==。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Activity.java
public void finish() {
    if (mParent == null) {
        int resultCode;
        Intent resultData;
        synchronized (this) {
            resultCode = mResultCode;
            resultData = mResultData;
        }
        ……
         //调用到AMS中的finishActivity
        if (ActivityManagerNative.getDefault()
            .finishActivity(mToken, resultCode, resultData)) {
            mFinished = true;
        }
        ……
    } else {
        mParent.finishFromChild(this);
    }
}

Activity的finish过程会通过Binder调用到AMS的finishActivity。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Override
public final boolean finishActivity(IBinder token, int resultCode, Intent resultData) {
    ……
    synchronized(this) {
        ActivityRecord r = ActivityRecord.isInStackLocked(token);
        ……
        final long origId = Binder.clearCallingIdentity();
        boolean res = r.task.stack.requestFinishActivityLocked(token, resultCode,
                resultData, "app-request", true);//终止当前activity
        Binder.restoreCallingIdentity(origId);
        return res;
    }
}

final boolean requestFinishActivityLocked(IBinder token, int resultCode,
        Intent resultData, String reason, boolean oomAdj) {
    ActivityRecord r = isInStackLocked(token);
    ...
    //终止当前activity
    finishActivityLocked(r, resultCode, resultData, reason, oomAdj);
    return true;
}

finishActivity调用到ActivityRecord对应的ActivityStack中的requestFinishActivityLocked。紧接着再调用finishActivityLocked。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//frameworks/base/services/java/com/android/server/am/ActivityStack.java
final boolean finishActivityLocked(ActivityRecord r, int resultCode, Intent resultData,
        String reason, boolean oomAdj) {
    ...
    if (mResumedActivity == r) {
        ……
        // Tell window manager to prepare for this one to be removed.
        mWindowManager.setAppVisibility(r.appToken, false);

        if (mPausingActivity == null) {
        
            startPausingLocked(false, false);//开始pause流程，这是finish周期的第一步
        }
    }
    ……
    return false;
}

finishActivityLocked通过startPauseingLocked方法来暂停当前的activity。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
final void startPausingLocked(boolean userLeaving, boolean uiSleeping) {
    
    ActivityRecord prev = mResumedActivity;//将要被暂停的activity
    
    mResumedActivity = null; //pause流程会将mResumeActivity置null
    mPausingActivity = prev;//正在被暂停的activity
    mLastPausedActivity = prev;//上一个被暂停的activity
    mLastNoHistoryActivity = (prev.intent.getFlags() & Intent.FLAG_ACTIVITY_NO_HISTORY) != 0
            || (prev.info.flags & ActivityInfo.FLAG_NO_HISTORY) != 0 ? prev : null;
    prev.state = ActivityState.PAUSING;//切换状态为PAUSING
    prev.task.touchActiveTime();
    clearLaunchTime(prev);
    final ActivityRecord next = mStackSupervisor.topRunningActivityLocked();//代表即将要启动的activity
    if (next == null || next.task != prev.task) {
        prev.updateThumbnail(screenshotActivities(prev), null);
    }
    stopFullyDrawnTraceIfNeeded();

    mService.updateCpuStats();

    if (prev.app != null && prev.app.thread != null) {//Launcher启动 走这里 
        ...
        prev.app.thread.schedulePauseActivity(prev.appToken, prev.finishing,
                    userLeaving, prev.configChangeFlags);//取出ApplicationThread对象通知其进入Paused状态
        ...
    } else {
        mPausingActivity = null;
        mLastPausedActivity = null;
        mLastNoHistoryActivity = null;
    }
    ...
}

startPausingLocked方法负责暂停当前activity，它通过IApplicationThread这个Binder代理调用schedulePauseActivity通知应用端暂停当前activity。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
private void handlePauseActivity(IBinder token, boolean finished,
        boolean userLeaving, int configChanges) {
    ActivityClientRecord r = mActivities.get(token);
    if (r != null) {
        //Slog.v(TAG, "userLeaving=" + userLeaving + " handling pause of " + r);
        if (userLeaving) {
            performUserLeavingActivity(r);
        }

        r.activity.mConfigChangeFlags |= configChanges;
        performPauseActivity(token, finished, r.isPreHoneycomb());//调用performPauseActivity函数来调用Activity.onPause回调

        // Make sure any pending writes are now committed.
        if (r.isPreHoneycomb()) {
            QueuedWork.waitToFinish();
        }
        //通知ActivityManagerService，这个Activity已经进入Paused状态了，ActivityManagerService现在可以完成未竟的事情
        // Tell the activity manager we have paused.
        try {
            ActivityManagerNative.getDefault().activityPaused(token);
        } catch (RemoteException ex) {
        }
    }
}

schedulePauseActivity调用handlePauseActivity方法来执行暂停过程，这里会回调Activity生命周期的onPause方法，完成暂停后通过activityPaused方法通知AMS。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//activity被暂停后 通知AMS已经执行完毕
@Override
public final void activityPaused(IBinder token) {
    final long origId = Binder.clearCallingIdentity();
    synchronized(this) {
        ActivityStack stack = ActivityRecord.getStackLocked(token);//获取当前的activityStack
        if (stack != null) {
            stack.activityPausedLocked(token, false);
        }
    }
    Binder.restoreCallingIdentity(origId);
}

//ActivityStack.java 通知activity被paused
final void activityPausedLocked(IBinder token, boolean timeout) {
    
    //这里的token是被暂停的activity的token    
    final ActivityRecord r = isInStackLocked(token);//得到暂停的activity Launcher启动即为Launcher对应的Activity
    if (r != null) {
        mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r);
        if (mPausingActivity == r) {//true 这个在startPausingLocked中被设置的 
            r.state = ActivityState.PAUSED;//改变状态为PAUSING->PAUSEd
            completePauseLocked();//完成暂停acitivty的操作
        }
        ...
    }
}

AMS的activityPaused通过ActivityStack的activityPausedLocked方法来完成进一步完成暂停Activity的工作。随后进一步调用completePauseLocked。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//完成暂停动作后的逻辑
private void completePauseLocked() {
    ActivityRecord prev = mPausingActivity;
    if (prev != null) {
        if (prev.finishing) {//主动finish时候是走这个分支，如果finishing标记为true表示这个activity是要finish
            prev = finishCurrentActivityLocked(prev, FINISH_AFTER_VISIBLE, false);
        }
        ...
        mPausingActivity = null;//完成了pause过程 这里需要将mPausingActivity置为null
    }

    final ActivityStack topStack = mStackSupervisor.getFocusedStack();
    if (!mService.isSleepingOrShuttingDown()) {//未休眠
        mStackSupervisor.resumeTopActivitiesLocked(topStack, prev, null);
    } 
    ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
//finish当前activity
final ActivityRecord finishCurrentActivityLocked(ActivityRecord r, int mode, boolean oomAdj) {
    ……
    // make sure the record is cleaned out of other places.
    mStackSupervisor.mStoppingActivities.remove(r);//从mStackSupervisor中移除activity的信息
    mStackSupervisor.mGoingToSleepActivities.remove(r);
    mStackSupervisor.mWaitingVisibleActivities.remove(r);
    if (mResumedActivity == r) {
        mResumedActivity = null;
    }
    final ActivityState prevState = r.state;
    if (DEBUG_STATES) Slog.v(TAG, "Moving to FINISHING: " + r);
    r.state = ActivityState.FINISHING;

    if (mode == FINISH_IMMEDIATELY
            || prevState == ActivityState.STOPPED
            || prevState == ActivityState.INITIALIZING) {
        // If this activity is already stopped, we can just finish
        // it right now.
        boolean activityRemoved = destroyActivityLocked(r, true,
                oomAdj, "finish-imm");
        if (activityRemoved) {
            mStackSupervisor.resumeTopActivitiesLocked();
        }
        return activityRemoved ? null : r;
    }

    // Need to go through the full pause cycle to get this
    // activity into the stopped state and then finish it.
    mStackSupervisor.mFinishingActivities.add(r);
    mStackSupervisor.getFocusedStack().resumeTopActivityLocked(null);
    return r;
}

completePauseLocked完成activity暂停的工作，这里的mPausingActivity就是当前finish的activity，由于是主动finish的，这里的prev.finishing为true，通过finishCurentActivityLocked完成暂停的工作，随后resumeTopActivitiesLocked启动当前栈顶的activity。这一部分工作在activity的启动过程有所介绍，这里不展开说明。这一流程会导致栈顶activity调用onRestart,onStart,onResume过程。我们看下acitivty执行onResume完成后会做什么。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
final void handleResumeActivity(IBinder token, boolean clearHide, boolean isForward,
    boolean reallyResume) {
    ...
    ActivityClientRecord r = performResumeActivity(token, clearHide);//回调OnResume       
    ...
    if (!r.onlyLocalRequest) {
        r.nextIdle = mNewActivities;
        mNewActivities = r;
        Looper.myQueue().addIdleHandler(new Idler());
    }
}

private class Idler implements MessageQueue.IdleHandler {
    @Override
    public final boolean queueIdle() {
        ActivityClientRecord a = mNewActivities;
        boolean stopProfiling = false;
        if (mBoundApplication != null && mProfiler.profileFd != null
                && mProfiler.autoStopProfiler) {
            stopProfiling = true;
        }
        if (a != null) {
            mNewActivities = null;
            IActivityManager am = ActivityManagerNative.getDefault();
            ActivityClientRecord prev;
            do {
                if (a.activity != null && !a.activity.mFinished) {
                    try {
                        am.activityIdle(a.token, a.createdConfig, stopProfiling);
                        a.createdConfig = null;
                    } catch (RemoteException ex) {
                        // Ignore
                    }
                }
                prev = a;
                a = a.nextIdle;
                prev.nextIdle = null;
            } while (a != null);
        }
        if (stopProfiling) {
            mProfiler.stopProfiling();
        }
        ensureJitEnabled();
        return false;
    }
}

activity处理resume过程中会在当前主线程的MessageQueue中添加一个addIdleHandler，这个handler的回调在MessageQueue中没有可以处理的消息后进行调用，而在回调中调用了AMS的activityIdle，这个方法开始处理前一个activity的finish的收尾工作。

1
2
3
4
5
6
7
8
9
10
11
12
13
@Override
public final void activityIdle(IBinder token, Configuration config, boolean stopProfiling) {
    final long origId = Binder.clearCallingIdentity();
    synchronized (this) {
        ActivityStack stack = ActivityRecord.getStackLocked(token);
        if (stack != null) {
            ActivityRecord r =
                    mStackSupervisor.activityIdleInternalLocked(token, false, config);
            ...
        }
    }
    Binder.restoreCallingIdentity(origId);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
final ActivityRecord activityIdleInternalLocked(final IBinder token, boolean fromTimeout,
            Configuration config) {
    ...
    ActivityRecord r = ActivityRecord.forToken(token);
    ...

    // Atomically retrieve all of the other things to do.
    stops = processStoppingActivitiesLocked(true);
    NS = stops != null ? stops.size() : 0;
    if ((NF=mFinishingActivities.size()) > 0) {//拷贝当前需要finish的activity
        finishes = new ArrayList<ActivityRecord>(mFinishingActivities);
        mFinishingActivities.clear();
    }
    ...
    //处理等待finish的activities
    for (int i = 0; i < NF; i++) {
        r = finishes.get(i);
        activityRemoved |= r.task.stack.destroyActivityLocked(r, true, false, "finish-idle");//终止activity
    }

    ...
    return r;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
final boolean destroyActivityLocked(ActivityRecord r,
            boolean removeFromApp, boolean oomAdj, String reason) {
    ...
    boolean removedFromHistory = false;

    cleanUpActivityLocked(r, false, false);

    final boolean hadApp = r.app != null;

    if (hadApp) {
        if (removeFromApp) {
            r.app.activities.remove(r);
            if (mService.mHeavyWeightProcess == r.app && r.app.activities.size() <= 0) {
                mService.mHeavyWeightProcess = null;
                mService.mHandler.sendEmptyMessage(
                        ActivityManagerService.CANCEL_HEAVY_NOTIFICATION_MSG);
            }
            //如果当前APP的Activity堆栈为空了，就说明当前Activity没有可见界面了，这个时候就需要动态更新这个APP的优先级
            if (r.app.activities.isEmpty()) {
                // No longer have activities, so update LRU list and oom adj.
                mService.updateLruProcessLocked(r.app, false, null);
                mService.updateOomAdjLocked();
            }
        }

        boolean skipDestroy = false;

        try {
            r.app.thread.scheduleDestroyActivity(r.appToken, r.finishing,
                    r.configChangeFlags);//通知应用端处理activity的destroy
        } 

        r.nowVisible = false;

        if (r.finishing && !skipDestroy) {
            r.state = ActivityState.DESTROYING;
            Message msg = mHandler.obtainMessage(DESTROY_TIMEOUT_MSG, r);
            mHandler.sendMessageDelayed(msg, DESTROY_TIMEOUT);
        } 
        ...
    } 
    ...
    return removedFromHistory;
}

destroyActivityLocked中主要就是通知应用端进行onStop，onDestroy生命周期的回调。

坚持原创技术分享，您的支持将鼓励我继续创作！